Spring MVC 函数式编程进阶

1. 前言

上一篇对 Spring MVC 的函数式接口编程进行了简单入门，让很多不知道的同学见识了这种新操作。也有反应这种看起来没有传统写法顺眼，其实大家都一样。但是我们还是要敢于接受和尝试新事物。Java Lambada 刚出来也是被人各种吐槽，现在我在很多项目都见到了它的身影。好了转回正题，本文是对上一篇的延伸，我们继续对 Functional Endpoint 进行一些了解和运用。范式转换其实上一篇已经介绍差不多了，但是一旦你初次接触这种方式往往会面临新的问题。

2. 新的问题

在使用这种风格时我们也会遇到一些新的问题。接下来我们将通过举例来一步步解决这些问题。

2.1 如何异常处理

接口异常处理是必须的。改成函数式风格后异常可以这样处理：

    /**
     * 接口附带异常处理逻辑.
     *
     * @param userService the user service
     * @return the user by name with error handle
     */
    public RouterFunction<ServerResponse> withErrorHandle() {
        return RouterFunctions.route()
                .GET("/userwitherrorhandle/{username}",
                        request -> ServerResponse.ok()
                          .body(userService.getByName(request.pathVariable("username"))))
                // 异常处理
                .onError(RuntimeException.class,
                        (e, request) -> EntityResponse.fromObject(e.getMessage())
                                .status(HttpStatus.INTERNAL_SERVER_ERROR)
                                .build())
                .build();
    }

你可以使用上面的 onError 方法及其重载方法进行接口的异常处理。但是传统方法有统一异常处理啊！不要捉急，后面我们也会进行统一异常的处理。

2.2 如何使用过滤器

我还有不少 Spring MVC 在使用过滤器呢，使用这种风格如何编写过滤器，上一篇漏掉了一个处理过滤器的函数式接口HandlerFilterFunction 。我们通过该接口来对请求进行过滤：

    /**
     * 对特定接口指定过滤器.
     *
     * @param userService the user service
     * @return the router function
     */
    public RouterFunction<ServerResponse> withFilter() {
        return RouterFunctions.route().POST("/save",
                request -> ServerResponse.ok()
                        .body(userService.saveUser(request.body(UserInfo.class))))
                // 执行了一个过滤器逻辑 参数携带了 save 放行 否则返回 bad request 并附带消息
                .filter((request, next) -> request.param("save").isPresent() ?
                        next.handle(request) :
                        ServerResponse.status(HttpStatus.BAD_REQUEST).body("no save"))
                .build();
    }

通过 filter 方法我们可以实现日志、安全策略、跨域等功能。

2.3 如何使用拦截器

使用函数式编程风格时并没有提供 Spring MVC 的拦截器 API，但是提供了类似过滤器前置/后置处理机制以达到同样的效果。

    public RouterFunction<ServerResponse> getUserByName() {
        return RouterFunctions.route()
                .GET("/user/{username}",
                        request -> ServerResponse.ok()
                         .body(userService.getByName(request.pathVariable("username"))))
                // 前置处理 打印 path
                .before(serverRequest -> {
                    log.info(serverRequest.path());
                    return serverRequest;
                })
                // 后置处理 如果响应状态为200 则打印 response ok
                .after(((serverRequest, serverResponse) -> {
                    if (serverResponse.statusCode() == HttpStatus.OK) {
                        log.info("response ok");
                    }
                    return serverResponse;
                })).build();
    }

当你请求/user/{username}时， before 和 after 方法将会分别进行前置和后置处理。

2.4 如何进行统一处理

传统方式我们每个Controller 处理的都是特定单一领域的业务，UserController 处理 User相关业务，我们会给它添加一个统一的前缀标识 /v1/user;OrderController处理 Order 相关业务,给它添加一个统一的前缀标识 /v1/order。使用函数式编程我们可以通过以下方式实现：

@Bean
RouterFunction<ServerResponse> userEndpoints(UserController userController) {
    return RouterFunctions.route()
            .path("/v2/user", builder -> builder
                    //  /get/{username} -> /v2/user//get/{username}
                    .add(userController.getUserByName()
                            //  /del/{username} -> /v2/user//del/{username}
                            .and(userController.delUser()
                                    // /save -> /v2/user/save
                                    .and(userController.saveUser()
                                            // /update -> /v2/user/update
                                            .and(userController.updateUser())))))
            .build();
}

你也可以使用 RouterFunctions.route().nest相关的方法进行实现。而且对这些路由进行分组聚合之后就可以统一过滤器、拦截器、异常处理。例如2.1提到的统一异常问题：

@Bean
RouterFunction<ServerResponse> nestEndpoints(UserController userController) {
    return RouterFunctions.route().nest(RequestPredicates.path("/v1/user"),
            builder -> builder
                    .add(userController.getUserByName())
                    .add(userController.delUser())
                    .add(userController.saveUser())
                    .add(userController.updateUser()))
            // 对上述路由进行统一的异常处理
            .onError(RuntimeException.class,
                    (throwable, serverRequest) -> ServerResponse
                            .status(HttpStatus.BAD_REQUEST)
                            .body("bad req"))
            .build();
}

3. 总结

本文主要对 Spring MVC 函数式开发和传统开发中等效的特性（过滤器、拦截器、分组聚合等）进行了简单的说明，更加贴合于实际运用。函数式风格开发更加灵活，但是同样让习惯命令式编程的开发者有点不适应，但是目前越来越被普遍的应用。所以如果有志于长期从事编程开发的同学来说，还是需要掌握的。本文的 demo 可通过关注公众号：Felordcn回复 mvcfun 获取。

往期回顾：

戳原文，更有料！